home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Visual Basic 5.0 (2nd Edition) / Hardcore Visual Basic 5.0 - Second Edition (1997)(Microsoft Press).iso / Source / Cpp4VB / WINTLB / WINBASE.ODL < prev    next >
Text File  |  1996-02-27  |  59KB  |  2,193 lines
  1.  
  2. #ifdef WIN32
  3. [
  4. uuid(54674048-3A82-101B-8181-00AA003743D3),
  5. helpstring("Win32 Base Functions"),
  6. dllname("KERNEL32.DLL")
  7. ]
  8. module WinBase {
  9.  
  10.  
  11.     [
  12.     usesgetlasterror,
  13.     entry("SearchPathA"),
  14.     helpstring("Searches lpPath for lpFileName with lpfExtension and returns full path result in lpBuffer and lpFilePart"),
  15.     ]
  16.     DWORD WINAPI SearchPath([in] LPCSTR lpPath, [in] LPCSTR lpFileName,
  17.                             [in] LPCSTR lpExtension,
  18.                             [in] DWORD nBufferLength,
  19.                             [in, out] LPSTR lpBuffer,
  20.                             [in, out] DWORD FAR *lpFilePart);
  21.  
  22.     [
  23.     usesgetlasterror,
  24.     entry("GetFullPathNameA"),
  25.     helpstring("Returns full path of lpFileName in lpBuffer and lpFilePart"),
  26.     ]
  27.     DWORD WINAPI GetFullPathName([in] LPCSTR lpFileName,
  28.                                  [in] DWORD nBufferLength,
  29.                                  [in, out] LPSTR lpBuffer,
  30.                                  [in, out] DWORD FAR *lpFilePart);
  31.  
  32.     [
  33.     usesgetlasterror,
  34.     entry("GetDiskFreeSpaceA"),
  35.     helpstring("Returns information about disk lpRootPathName in lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters"),
  36.     ]
  37.     BOOL WINAPI GetDiskFreeSpace([in] LPCSTR lpRootPathName,
  38.                                  [in, out] DWORD FAR *lpSectorsPerCluster,
  39.                                  [in, out] DWORD FAR *lpBytesPerSector,
  40.                                  [in, out] DWORD FAR *lpNumberOfFreeClusters,
  41.                                  [in, out] DWORD FAR *lpTotalNumberOfClusters);
  42.  
  43.     [
  44.     usesgetlasterror,
  45.     entry("GetDriveTypeA"),
  46.     helpstring("Returns the type of disk lpRootPathName"),
  47.     ]
  48.     UINT WINAPI GetDriveType([in]LPCSTR lpRootPathName);
  49.  
  50.     [
  51.     usesgetlasterror,
  52.     entry("GetTempPathA"),
  53.     helpstring("Returns the directory for temporary files in lpBuffer"),
  54.     ]
  55.     DWORD WINAPI GetTempPath([in] DWORD nBufferLength,
  56.                              [in,out] LPSTR lpBuffer);
  57.  
  58.     [
  59.     usesgetlasterror,
  60.     entry("GetTempFileNameA"),
  61.     helpstring("Returns name of a unique file with lpPrefixString for directory lpPathName in lpTempfileName"),
  62.     ]
  63.     UINT WINAPI GetTempFileName([in] LPCSTR lpPathName,
  64.                                 [in] LPCSTR lpPrefixString,
  65.                                 [in] UINT uUnique,
  66.                                 [in, out] LPSTR lpTempFileName);
  67.  
  68.     [
  69.     usesgetlasterror,
  70.     entry("GetLogicalDriveStringsA"),
  71.     helpstring("Returns root path strings (with terminating double null) for all valid drives in lpBuffer"),
  72.     ]
  73.     DWORD WINAPI GetLogicalDriveStrings([in] DWORD nBufferLength,
  74.                                         [in, out] LPSTR lpBuffer);
  75.  
  76.     [
  77.     usesgetlasterror,
  78.     entry("GetLogicalDrives"),
  79.     helpstring("Returns valid lettered drives in bit field (A in bit 0)"),
  80.     ]
  81.     DWORD WINAPI GetLogicalDrives(VOID);
  82.  
  83.     [
  84.     usesgetlasterror,
  85.     entry("GetEnvironmentStrings"),
  86.     helpstring("Returns pointer to environment variable strings (with terminating double null)"),
  87.     ]
  88.     DWORD WINAPI GetEnvironmentStrings(VOID);
  89.  
  90.     [
  91.     usesgetlasterror,
  92.     entry("GetEnvironmentVariableA"),
  93.     helpstring("Returns contents of environment variable lpName in lpBuffer"),
  94.     ]
  95.     DWORD WINAPI GetEnvironmentVariable([in] LPCSTR lpName,
  96.                                         [in, out] LPSTR lpBuffer,
  97.                                         [in] DWORD nSize
  98.                                         );
  99.  
  100.     [
  101.     usesgetlasterror,
  102.     entry("SetEnvironmentVariableA"),
  103.     helpstring("Sets environment variable lpName to value lpValue (deletes variable if lpValue is Null)"),
  104.     ]
  105.     BOOL WINAPI SetEnvironmentVariable([in] LPCSTR lpName,
  106.                                        [in] LPCSTR lpValue);
  107.  
  108.     [
  109.     usesgetlasterror,
  110.     entry("SetEnvironmentVariableA"),
  111.     helpstring("Sets environment variable lpName to value lpValue (deletes variable if lpValue is Null)"),
  112.     ]
  113.     BOOL WINAPI SetEnvVariable([in] LPCSTR lpName,
  114.                                [in] LPCSTR lpValue);
  115.     [
  116.     usesgetlasterror,
  117.     entry("GetLastError"),
  118.     helpstring("Returns the number of the last error to occur"),
  119.     ]
  120.     DWORD WINAPI GetLastError(VOID);
  121.  
  122.     [
  123.     usesgetlasterror,
  124.     entry("SetLastError"),
  125.     helpstring("Sets the last error number to dwErrCode"),
  126.     ]
  127.     VOID WINAPI SetLastError([in] DWORD dwErrCode);
  128.  
  129.     [
  130.     usesgetlasterror,
  131.     entry("GetComputerNameA"),
  132.     helpstring("Gets the computer (machine) name"),
  133.     ]
  134.     BOOL WINAPI GetComputerName([in, out] LPSTR lpBuffer,
  135.                                 [in, out] DWORD FAR * nSize);
  136.  
  137.     [
  138.     usesgetlasterror,
  139.     entry("SetComputerNameA"),
  140.     helpstring("Sets the computer (machine) name"),
  141.     ]
  142.     BOOL WINAPI SetComputerName([in] LPCSTR lpComputerName);
  143.  
  144.     [
  145.     usesgetlasterror,
  146.     entry("GetVolumeInformationA"),
  147.     helpstring("Gets information about a disk including volume name, serial number, maximum component length, and file system name"),
  148.     ]
  149.     BOOL WINAPI GetVolumeInformation([in] LPCSTR lpRootPathName,
  150.                                      [in, out] LPSTR lpVolumeNameBuffer,
  151.                                      [in] DWORD nVolumeNameSize,
  152.                                      [in, out] DWORD FAR *lpVolumeSerialNumber,
  153.                                      [in, out] DWORD FAR *lpMaximumComponentLength,
  154.                                      [in, out] DWORD FAR *lpFileSystemFlags,
  155.                                      [in, out] LPSTR lpFileSystemNameBuffer,
  156.                                      [in] DWORD nFileSystemNameSize);
  157.  
  158.     [
  159.     entry("FlushFileBuffers"),
  160.     helpstring("Writes file buffers for an open handle to disk"),
  161.     ]
  162.     BOOL WINAPI FlushFileBuffers([in] HANDLE hFile);
  163.  
  164.     [
  165.     entry("Beep"),
  166.     helpstring("Plays a sound of given frequency and duration"),
  167.     ]
  168.     BOOL WINAPI Beep([in] DWORD dwFreq, [in] DWORD dwDuration);
  169.  
  170.     /* To be implemented
  171.     BOOL WINAPI FreeEnvironmentStringsA(
  172.         LPSTR
  173.         );
  174.  
  175.     DWORD WINAPI ExpandEnvironmentStringsA(
  176.         LPCSTR lpSrc,
  177.         LPSTR lpDst,
  178.         DWORD nSize
  179.         );
  180.  
  181.     */
  182.  
  183.     [
  184.     entry("SetVolumeLabelA"),
  185.     helpstring("Sets label of file system volume specified by root path"),
  186.     ]
  187.     BOOL WINAPI SetVolumeLabel([in] LPCSTR lpRootPathName,
  188.                                [in] LPCSTR lpVolumeName);
  189.  
  190.     [
  191.     entry("Sleep"),
  192.     helpstring("Suspends execution of the current thread for a specified interval"),
  193.     ]
  194.     VOID WINAPI Sleep([in] DWORD dwMilliseconds);
  195.  
  196.  
  197.     /* Find file not implemented
  198.     HANDLE WINAPI FindFirstFileA(
  199.         LPCSTR lpFileName,
  200.         LPWIN32_FIND_DATAA lpFindFileData
  201.         );
  202.  
  203.     BOOL WINAPI FindNextFileA(
  204.         HANDLE hFindFile,
  205.         LPWIN32_FIND_DATAA lpFindFileData
  206.         );
  207.  
  208.     BOOL WINAPI FindClose(HANDLE hFindFile);
  209.  
  210.     typedef struct _WIN32_FIND_DATAA {
  211.         DWORD dwFileAttributes;
  212.         FILETIME ftCreationTime;
  213.         FILETIME ftLastAccessTime;
  214.         FILETIME ftLastWriteTime;
  215.         DWORD nFileSizeHigh;
  216.         DWORD nFileSizeLow;
  217.         DWORD dwReserved0;
  218.         DWORD dwReserved1;
  219.         CHAR   cFileName[ MAX_PATH ];
  220.         CHAR   cAlternateFileName[ 14 ];
  221.     } WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
  222.     */
  223.  
  224.     /* Interlocked not implemented
  225.     LONG WINAPI InterlockedIncrement(
  226.         LPLONG lpAddend
  227.         );
  228.  
  229.     LONG WINAPI InterlockedDecrement(
  230.         LPLONG lpAddend
  231.         );
  232.  
  233.     LONG WINAPI InterlockedExchange(
  234.         LPLONG Target,
  235.         LONG Value
  236.         );
  237.     */
  238.  
  239.     /* Can't implement GlobalMemoryStatus
  240.     VOID WINAPI GlobalMemoryStatus(
  241.         LPMEMORYSTATUS lpBuffer
  242.         );
  243.     */
  244.  
  245.     /* Instruction cache not implemented
  246.     BOOL WINAPI FlushInstructionCache(
  247.         HANDLE hProcess,
  248.         LPCVOID lpBaseAddress,
  249.         DWORD dwSize
  250.         );
  251.     */
  252.  
  253.     /*
  254.     typedef LONG (WINAPI *PTOP_LEVEL_EXCEPTION_FILTER)(
  255.         struct _EXCEPTION_POINTERS *ExceptionInfo
  256.         );
  257.     typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;
  258.     */
  259.  
  260.     /* Threads not implemented
  261.     HANDLE WINAPI CreateThread(
  262.         LPSECURITY_ATTRIBUTES lpThreadAttributes,
  263.         DWORD dwStackSize,
  264.         LPTHREAD_START_ROUTINE lpStartAddress,
  265.         LPVOID lpParameter,
  266.         DWORD dwCreationFlags,
  267.         LPDWORD lpThreadId
  268.         );
  269.  
  270.     HANDLE WINAPI CreateRemoteThread(
  271.         HANDLE hProcess,
  272.         LPSECURITY_ATTRIBUTES lpThreadAttributes,
  273.         DWORD dwStackSize,
  274.         LPTHREAD_START_ROUTINE lpStartAddress,
  275.         LPVOID lpParameter,
  276.         DWORD dwCreationFlags,
  277.         LPDWORD lpThreadId
  278.         );
  279.  
  280.     HANDLE WINAPI GetCurrentThread(
  281.         VOID
  282.         );
  283.  
  284.     DWORD WINAPI GetCurrentThreadId(
  285.         VOID
  286.         );
  287.  
  288.     DWORD WINAPI SetThreadAffinityMask(
  289.         HANDLE hThread,
  290.         DWORD dwThreadAffinityMask
  291.         );
  292.  
  293.     BOOL WINAPI SetThreadPriority(
  294.         HANDLE hThread,
  295.         int nPriority
  296.         );
  297.  
  298.     int WINAPI GetThreadPriority(
  299.         HANDLE hThread
  300.         );
  301.  
  302.     BOOL WINAPI GetThreadTimes(
  303.         HANDLE hThread,
  304.         LPFILETIME lpCreationTime,
  305.         LPFILETIME lpExitTime,
  306.         LPFILETIME lpKernelTime,
  307.         LPFILETIME lpUserTime
  308.         );
  309.  
  310.     VOID WINAPI ExitThread(
  311.         DWORD dwExitCode
  312.         );
  313.  
  314.     BOOL WINAPI TerminateThread(
  315.         HANDLE hThread,
  316.         DWORD dwExitCode
  317.         );
  318.  
  319.     BOOL WINAPI GetExitCodeThread(
  320.         HANDLE hThread,
  321.         LPDWORD lpExitCode
  322.         );
  323.  
  324.     BOOL WINAPI GetThreadSelectorEntry(
  325.         HANDLE hThread,
  326.         DWORD dwSelector,
  327.         LPLDT_ENTRY lpSelectorEntry
  328.         );
  329.     */
  330.  
  331.     /* Completion not implemented
  332.     BOOL WINAPI GetOverlappedResult(
  333.         HANDLE hFile,
  334.         LPOVERLAPPED lpOverlapped,
  335.         LPDWORD lpNumberOfBytesTransferred,
  336.         BOOL bWait
  337.         );
  338.  
  339.     HANDLE WINAPI CreateIoCompletionPort(
  340.         HANDLE FileHandle,
  341.         HANDLE ExistingCompletionPort,
  342.         DWORD CompletionKey,
  343.         DWORD NumberOfConcurrentThreads
  344.         );
  345.  
  346.     BOOL WINAPI GetQueuedCompletionStatus(
  347.         HANDLE CompletionPort,
  348.         LPDWORD lpNumberOfBytesTransferred,
  349.         LPDWORD lpCompletionKey,
  350.         LPOVERLAPPED *lpOverlapped,
  351.         DWORD dwMilliseconds
  352.         );
  353.     */
  354.  
  355.     /* Debugger support not implemented
  356.     BOOL WINAPI ReadProcessMemory(
  357.         HANDLE hProcess,
  358.         LPCVOID lpBaseAddress,
  359.         LPVOID lpBuffer,
  360.         DWORD nSize,
  361.         LPDWORD lpNumberOfBytesRead
  362.         );
  363.  
  364.     BOOL WINAPI WriteProcessMemory(
  365.         HANDLE hProcess,
  366.         LPVOID lpBaseAddress,
  367.         LPVOID lpBuffer,
  368.         DWORD nSize,
  369.         LPDWORD lpNumberOfBytesWritten
  370.         );
  371.  
  372.     BOOL WINAPI GetThreadContext(
  373.         HANDLE hThread,
  374.         LPCONTEXT lpContext
  375.         );
  376.  
  377.     BOOL WINAPI SetThreadContext(
  378.         HANDLE hThread,
  379.         CONST CONTEXT *lpContext
  380.         );
  381.  
  382.     DWORD WINAPI SuspendThread(
  383.         HANDLE hThread
  384.         );
  385.  
  386.     DWORD WINAPI ResumeThread(
  387.         HANDLE hThread
  388.         );
  389.  
  390.     BOOL WINAPI WaitForDebugEvent(
  391.         LPDEBUG_EVENT lpDebugEvent,
  392.         DWORD dwMilliseconds
  393.         );
  394.  
  395.     BOOL WINAPI ContinueDebugEvent(
  396.         DWORD dwProcessId,
  397.         DWORD dwThreadId,
  398.         DWORD dwContinueStatus
  399.         );
  400.  
  401.     BOOL WINAPI DebugActiveProcess(
  402.         DWORD dwProcessId
  403.         );
  404.     */
  405.  
  406.     /* Critical sections not implemented
  407.     VOID WINAPI InitializeCriticalSection(
  408.         LPCRITICAL_SECTION lpCriticalSection
  409.         );
  410.  
  411.     VOID WINAPI EnterCriticalSection(
  412.         LPCRITICAL_SECTION lpCriticalSection
  413.         );
  414.  
  415.     VOID WINAPI LeaveCriticalSection(
  416.         LPCRITICAL_SECTION lpCriticalSection
  417.         );
  418.  
  419.     VOID WINAPI DeleteCriticalSection(
  420.         LPCRITICAL_SECTION lpCriticalSection
  421.         );
  422.     */
  423.  
  424.     /* Interprocess communication not implemented
  425.     BOOL WINAPI SetEvent(
  426.         HANDLE hEvent
  427.         );
  428.  
  429.     BOOL WINAPI ResetEvent(
  430.         HANDLE hEvent
  431.         );
  432.  
  433.     BOOL WINAPI PulseEvent(
  434.         HANDLE hEvent
  435.         );
  436.  
  437.     BOOL WINAPI ReleaseSemaphore(
  438.         HANDLE hSemaphore,
  439.         LONG lReleaseCount,
  440.         LPLONG lpPreviousCount
  441.         );
  442.  
  443.     BOOL WINAPI ReleaseMutex(
  444.         HANDLE hMutex
  445.         );
  446.     */
  447.  
  448.     [
  449.     usesgetlasterror,
  450.     entry("WaitForSingleObject"),
  451.     helpstring("Waits until the specified object reaches the signaled state, or until the time-out elapses"),
  452.     ]
  453.     DWORD WINAPI WaitForSingleObject(
  454.         [in] HANDLE hHandle,
  455.         [in] DWORD dwMilliseconds
  456.         );
  457.  
  458.     [
  459.     usesgetlasterror,
  460.     entry("WaitForMultipleObjects"),
  461.     helpstring("Waits until any one or all of the specified objects reaches the signaled state, or until the time-out elapses"),
  462.     ]
  463.     DWORD WINAPI WaitForMultipleObjects(
  464.         [in] DWORD nCount,
  465.         [in, out] HANDLE *lpHandles,
  466.         [in] BOOL bWaitAll,
  467.         [in] DWORD dwMilliseconds
  468.         );
  469.  
  470.     /*
  471.     typedef
  472.     VOID
  473.     (WINAPI *LPOVERLAPPED_COMPLETION_ROUTINE)(
  474.         DWORD dwErrorCode,
  475.         DWORD dwNumberOfBytesTransfered,
  476.         LPOVERLAPPED lpOverlapped
  477.         );
  478.  
  479.     DWORD WINAPI SleepEx(
  480.         DWORD dwMilliseconds,
  481.         BOOL bAlertable
  482.         );
  483.  
  484.     DWORD WINAPI WaitForSingleObjectEx(
  485.         HANDLE hHandle,
  486.         DWORD dwMilliseconds,
  487.         BOOL bAlertable
  488.         );
  489.  
  490.     DWORD WINAPI WaitForMultipleObjectsEx(
  491.         DWORD nCount,
  492.         CONST HANDLE *lpHandles,
  493.         BOOL bWaitAll,
  494.         DWORD dwMilliseconds,
  495.         BOOL bAlertable
  496.         );
  497.  
  498.     HANDLE WINAPI CreateMutexA(
  499.         LPSECURITY_ATTRIBUTES lpMutexAttributes,
  500.         BOOL bInitialOwner,
  501.         LPCSTR lpName
  502.         );
  503.  
  504.     HANDLE WINAPI OpenMutexA(
  505.         DWORD dwDesiredAccess,
  506.         BOOL bInheritHandle,
  507.         LPCSTR lpName
  508.         );
  509.  
  510.     HANDLE WINAPI CreateEventA(
  511.         LPSECURITY_ATTRIBUTES lpEventAttributes,
  512.         BOOL bManualReset,
  513.         BOOL bInitialState,
  514.         LPCSTR lpName
  515.         );
  516.  
  517.     HANDLE WINAPI OpenEventA(
  518.         DWORD dwDesiredAccess,
  519.         BOOL bInheritHandle,
  520.         LPCSTR lpName
  521.         );
  522.  
  523.     HANDLE WINAPI CreateSemaphoreA(
  524.         LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
  525.         LONG lInitialCount,
  526.         LONG lMaximumCount,
  527.         LPCSTR lpName
  528.         );
  529.  
  530.     HANDLE WINAPI OpenSemaphoreA(
  531.         DWORD dwDesiredAccess,
  532.         BOOL bInheritHandle,
  533.         LPCSTR lpName
  534.         );
  535.  
  536.     */
  537.  
  538.     /* Tape and backup not implemented
  539.     DWORD WINAPI SetTapePosition(
  540.         HANDLE hDevice,
  541.         DWORD dwPositionMethod,
  542.         DWORD dwPartition,
  543.         DWORD dwOffsetLow,
  544.         DWORD dwOffsetHigh,
  545.         BOOL bImmediate
  546.         );
  547.  
  548.     DWORD WINAPI GetTapePosition(
  549.         HANDLE hDevice,
  550.         DWORD dwPositionType,
  551.         LPDWORD lpdwPartition,
  552.         LPDWORD lpdwOffsetLow,
  553.         LPDWORD lpdwOffsetHigh
  554.         );
  555.  
  556.     DWORD WINAPI PrepareTape(
  557.         HANDLE hDevice,
  558.         DWORD dwOperation,
  559.         BOOL bImmediate
  560.         );
  561.  
  562.     DWORD WINAPI EraseTape(
  563.         HANDLE hDevice,
  564.         DWORD dwEraseType,
  565.         BOOL bImmediate
  566.         );
  567.  
  568.     DWORD WINAPI CreateTapePartition(
  569.         HANDLE hDevice,
  570.         DWORD dwPartitionMethod,
  571.         DWORD dwCount,
  572.         DWORD dwSize
  573.         );
  574.  
  575.     DWORD WINAPI WriteTapemark(
  576.         HANDLE hDevice,
  577.         DWORD dwTapemarkType,
  578.         DWORD dwTapemarkCount,
  579.         BOOL bImmediate
  580.         );
  581.  
  582.     DWORD WINAPI GetTapeStatus(
  583.         HANDLE hDevice
  584.         );
  585.  
  586.     DWORD WINAPI GetTapeParameters(
  587.         HANDLE hDevice,
  588.         DWORD dwOperation,
  589.         LPDWORD lpdwSize,
  590.         LPVOID lpTapeInformation
  591.         );
  592.  
  593.     //const int GET_TAPE_MEDIA_INFORMATION = 0;
  594.     //const int GET_TAPE_DRIVE_INFORMATION = 1;
  595.  
  596.     DWORD WINAPI SetTapeParameters(
  597.         HANDLE hDevice,
  598.         DWORD dwOperation,
  599.         LPVOID lpTapeInformation
  600.         );
  601.  
  602.     //const int SET_TAPE_MEDIA_INFORMATION = 0;
  603.     //const int SET_TAPE_DRIVE_INFORMATION = 1;
  604.  
  605.     BOOL WINAPI BackupRead(
  606.         HANDLE hFile,
  607.         LPBYTE lpBuffer,
  608.         DWORD nNumberOfBytesToRead,
  609.         LPDWORD lpNumberOfBytesRead,
  610.         BOOL bAbort,
  611.         BOOL bProcessSecurity,
  612.         LPVOID *lpContext
  613.         );
  614.  
  615.     BOOL WINAPI BackupSeek(
  616.         HANDLE hFile,
  617.         DWORD  dwLowBytesToSeek,
  618.         DWORD  dwHighBytesToSeek,
  619.         LPDWORD lpdwLowByteSeeked,
  620.         LPDWORD lpdwHighByteSeeked,
  621.         LPVOID *lpContext
  622.         );
  623.  
  624.     BOOL WINAPI BackupWrite(
  625.         HANDLE hFile,
  626.         LPBYTE lpBuffer,
  627.         DWORD nNumberOfBytesToWrite,
  628.         LPDWORD lpNumberOfBytesWritten,
  629.         BOOL bAbort,
  630.         BOOL bProcessSecurity,
  631.         LPVOID *lpContext
  632.         );
  633.  
  634.     typedef struct _WIN32_STREAM_ID {
  635.             DWORD          dwStreamId ;
  636.             DWORD          dwStreamAttributes ;
  637.             LARGE_INTEGER  Size ;
  638.             DWORD          dwStreamNameSize ;
  639.             WCHAR          cStreamName[ ANYSIZE_ARRAY ] ;
  640.     } WIN32_STREAM_ID, *LPWIN32_STREAM_ID ;
  641.  
  642.     //  Stream Ids
  643.  
  644.     const DWORD BACKUP_INVALID         = 0x00000000;
  645.     const DWORD BACKUP_DATA            = 0x00000001;
  646.     const DWORD BACKUP_EA_DATA         = 0x00000002;
  647.     const DWORD BACKUP_SECURITY_DATA   = 0x00000003;
  648.     const DWORD BACKUP_ALTERNATE_DATA  = 0x00000004;
  649.     const DWORD BACKUP_LINK            = 0x00000005;
  650.     const DWORD BACKUP_PROPERTY_DATA   = 0x00000006;
  651.  
  652.     //  Stream Attributes
  653.  
  654.     const DWORD STREAM_NORMAL_ATTRIBUTE    = 0x00000000;
  655.     const DWORD STREAM_MODIFIED_WHEN_READ  = 0x00000001;
  656.     const DWORD STREAM_CONTAINS_SECURITY   = 0x00000002;
  657.     const DWORD STREAM_CONTAINS_PROPERTIES = 0x00000004;
  658.  
  659.     */
  660.  
  661.     /* Time not implemented
  662.     VOID WINAPI GetSystemTime(
  663.         LPSYSTEMTIME lpSystemTime
  664.         );
  665.  
  666.     BOOL WINAPI SetSystemTime(
  667.         CONST SYSTEMTIME *lpSystemTime
  668.         );
  669.  
  670.     VOID WINAPI GetLocalTime(
  671.         LPSYSTEMTIME lpSystemTime
  672.         );
  673.  
  674.     BOOL WINAPI SetLocalTime(
  675.         CONST SYSTEMTIME *lpSystemTime
  676.         );
  677.  
  678.     typedef struct _TIME_ZONE_INFORMATION {
  679.         LONG Bias;
  680.         WCHAR StandardName[ 32 ];
  681.         SYSTEMTIME StandardDate;
  682.         LONG StandardBias;
  683.         WCHAR DaylightName[ 32 ];
  684.         SYSTEMTIME DaylightDate;
  685.         LONG DaylightBias;
  686.     } TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;
  687.  
  688.     BOOL WINAPI SystemTimeToTzSpecificLocalTime(
  689.         LPTIME_ZONE_INFORMATION lpTimeZoneInformation,
  690.         LPSYSTEMTIME lpUniversalTime,
  691.         LPSYSTEMTIME lpLocalTime
  692.         );
  693.  
  694.     DWORD WINAPI GetTimeZoneInformation(
  695.         LPTIME_ZONE_INFORMATION lpTimeZoneInformation
  696.         );
  697.  
  698.     BOOL WINAPI SetTimeZoneInformation(
  699.         CONST TIME_ZONE_INFORMATION *lpTimeZoneInformation
  700.         );
  701.  
  702.     //
  703.     // Routines to convert back and forth between system time and file time
  704.     //
  705.  
  706.     BOOL WINAPI SystemTimeToFileTime(
  707.         CONST SYSTEMTIME *lpSystemTime,
  708.         LPFILETIME lpFileTime
  709.         );
  710.  
  711.     BOOL WINAPI FileTimeToLocalFileTime(
  712.         CONST FILETIME *lpFileTime,
  713.         LPFILETIME lpLocalFileTime
  714.         );
  715.  
  716.     BOOL WINAPI LocalFileTimeToFileTime(
  717.         CONST FILETIME *lpLocalFileTime,
  718.         LPFILETIME lpFileTime
  719.         );
  720.  
  721.     BOOL WINAPI FileTimeToSystemTime(
  722.         CONST FILETIME *lpFileTime,
  723.         LPSYSTEMTIME lpSystemTime
  724.         );
  725.  
  726.     LONG WINAPI CompareFileTime(
  727.         CONST FILETIME *lpFileTime1,
  728.         CONST FILETIME *lpFileTime2
  729.         );
  730.  
  731.     BOOL WINAPI FileTimeToDosDateTime(
  732.         CONST FILETIME *lpFileTime,
  733.         LPWORD lpFatDate,
  734.         LPWORD lpFatTime
  735.         );
  736.  
  737.     BOOL WINAPI DosDateTimeToFileTime(
  738.         WORD wFatDate,
  739.         WORD wFatTime,
  740.         LPFILETIME lpFileTime
  741.         );
  742.  
  743.     BOOL WINAPI SetSystemTimeAdjustment(
  744.         DWORD dwTimeAdjustment,
  745.         BOOL  bTimeAdjustmentDisabled
  746.         );
  747.  
  748.     BOOL WINAPI GetSystemTimeAdjustment(
  749.         PDWORD lpTimeAdjustment,
  750.         PDWORD lpTimeIncrement,
  751.         PBOOL  lpTimeAdjustmentDisabled
  752.         );
  753.     */
  754.  
  755.     /* GetSystemInfo can't be implemented
  756.     VOID WINAPI GetSystemInfo(
  757.         LPSYSTEM_INFO lpSystemInfo
  758.         );
  759.     */
  760.  
  761.     /* Format message not implemented
  762.     DWORD WINAPI FormatMessageA(
  763.         DWORD dwFlags,
  764.         LPCVOID lpSource,
  765.         DWORD dwMessageId,
  766.         DWORD dwLanguageId,
  767.         LPSTR lpBuffer,
  768.         DWORD nSize,
  769.         va_list *Arguments
  770.         );
  771.  
  772.     const DWORD FORMAT_MESSAGE_ALLOCATE_BUFFER  = 0x00000100;
  773.     const DWORD FORMAT_MESSAGE_IGNORE_INSERTS   = 0x00000200;
  774.     const DWORD FORMAT_MESSAGE_FROM_STRING      = 0x00000400;
  775.     const DWORD FORMAT_MESSAGE_FROM_HMODULE     = 0x00000800;
  776.     const DWORD FORMAT_MESSAGE_FROM_SYSTEM      = 0x00001000;
  777.     const DWORD FORMAT_MESSAGE_ARGUMENT_ARRAY   = 0x00002000;
  778.     const DWORD FORMAT_MESSAGE_MAX_WIDTH_MASK   = 0x000000FF;
  779.     */
  780.  
  781.     /* Pipes not implemented
  782.     HANDLE WINAPI CreateNamedPipeA(
  783.         LPCSTR lpName,
  784.         DWORD dwOpenMode,
  785.         DWORD dwPipeMode,
  786.         DWORD nMaxInstances,
  787.         DWORD nOutBufferSize,
  788.         DWORD nInBufferSize,
  789.         DWORD nDefaultTimeOut,
  790.         LPSECURITY_ATTRIBUTES lpSecurityAttributes
  791.         );
  792.  
  793.     BOOL WINAPI GetNamedPipeHandleStateA(
  794.         HANDLE hNamedPipe,
  795.         LPDWORD lpState,
  796.         LPDWORD lpCurInstances,
  797.         LPDWORD lpMaxCollectionCount,
  798.         LPDWORD lpCollectDataTimeout,
  799.         LPSTR lpUserName,
  800.         DWORD nMaxUserNameSize
  801.         );
  802.  
  803.     BOOL WINAPI CallNamedPipeA(
  804.         LPCSTR lpNamedPipeName,
  805.         LPVOID lpInBuffer,
  806.         DWORD nInBufferSize,
  807.         LPVOID lpOutBuffer,
  808.         DWORD nOutBufferSize,
  809.         LPDWORD lpBytesRead,
  810.         DWORD nTimeOut
  811.         );
  812.  
  813.     BOOL WINAPI WaitNamedPipeA(
  814.         LPCSTR lpNamedPipeName,
  815.         DWORD nTimeOut
  816.         );
  817.  
  818.     BOOL WINAPI CreatePipe(
  819.         PHANDLE hReadPipe,
  820.         PHANDLE hWritePipe,
  821.         LPSECURITY_ATTRIBUTES lpPipeAttributes,
  822.         DWORD nSize
  823.         );
  824.  
  825.     BOOL WINAPI ConnectNamedPipe(
  826.         HANDLE hNamedPipe,
  827.         LPOVERLAPPED lpOverlapped
  828.         );
  829.  
  830.     BOOL WINAPI DisconnectNamedPipe(
  831.         HANDLE hNamedPipe
  832.         );
  833.  
  834.     BOOL WINAPI SetNamedPipeHandleState(
  835.         HANDLE hNamedPipe,
  836.         LPDWORD lpMode,
  837.         LPDWORD lpMaxCollectionCount,
  838.         LPDWORD lpCollectDataTimeout
  839.         );
  840.  
  841.     BOOL WINAPI GetNamedPipeInfo(
  842.         HANDLE hNamedPipe,
  843.         LPDWORD lpFlags,
  844.         LPDWORD lpOutBufferSize,
  845.         LPDWORD lpInBufferSize,
  846.         LPDWORD lpMaxInstances
  847.         );
  848.  
  849.     BOOL WINAPI PeekNamedPipe(
  850.         HANDLE hNamedPipe,
  851.         LPVOID lpBuffer,
  852.         DWORD nBufferSize,
  853.         LPDWORD lpBytesRead,
  854.         LPDWORD lpTotalBytesAvail,
  855.         LPDWORD lpBytesLeftThisMessage
  856.         );
  857.  
  858.     BOOL WINAPI TransactNamedPipe(
  859.         HANDLE hNamedPipe,
  860.         LPVOID lpInBuffer,
  861.         DWORD nInBufferSize,
  862.         LPVOID lpOutBuffer,
  863.         DWORD nOutBufferSize,
  864.         LPDWORD lpBytesRead,
  865.         LPOVERLAPPED lpOverlapped
  866.         );
  867.     */
  868.  
  869.     /* Mail slots not implemented
  870.     HANDLE WINAPI CreateMailslotA(
  871.         LPCSTR lpName,
  872.         DWORD nMaxMessageSize,
  873.         DWORD lReadTimeout,
  874.         LPSECURITY_ATTRIBUTES lpSecurityAttributes
  875.         );
  876.  
  877.     BOOL WINAPI GetMailslotInfo(
  878.         HANDLE hMailslot,
  879.         LPDWORD lpMaxMessageSize,
  880.         LPDWORD lpNextSize,
  881.         LPDWORD lpMessageCount,
  882.         LPDWORD lpReadTimeout
  883.         );
  884.  
  885.     BOOL WINAPI SetMailslotInfo(
  886.         HANDLE hMailslot,
  887.         DWORD lReadTimeout
  888.         );
  889.     */
  890.  
  891.     [
  892.     usesgetlasterror,
  893.     entry("MapViewOfFile"),
  894.     helpstring("Opens view of specified file mapping"),
  895.     ]
  896.     LPVOID WINAPI MapViewOfFile(
  897.         [in] HANDLE hFileMappingObject,
  898.         [in] DWORD dwDesiredAccess,
  899.         [in] DWORD dwFileOffsetHigh,
  900.         [in] DWORD dwFileOffsetLow,
  901.         [in] DWORD dwNumberOfBytesToMap
  902.         );
  903.  
  904.     [
  905.     usesgetlasterror,
  906.     entry("MapViewOfFileEx"),
  907.     helpstring("Opens view of specified file mapping at suggested address"),
  908.     ]
  909.     LPVOID WINAPI MapViewOfFileEx(
  910.         [in] HANDLE hFileMappingObject,
  911.         [in] DWORD dwDesiredAccess,
  912.         [in] DWORD dwFileOffsetHigh,
  913.         [in] DWORD dwFileOffsetLow,
  914.         [in] DWORD dwNumberOfBytesToMap,
  915.         [in] LPVOID lpBaseAddress
  916.         );
  917.  
  918.     [
  919.     usesgetlasterror,
  920.     entry("FlushViewOfFile"),
  921.     helpstring("Writes file mapping to disk"),
  922.     ]
  923.     BOOL WINAPI FlushViewOfFile(
  924.         [in] LPCVOID lpBaseAddress,
  925.         [in] DWORD dwNumberOfBytesToFlush
  926.         );
  927.  
  928.     [
  929.     usesgetlasterror,
  930.     entry("UnmapViewOfFile"),
  931.     helpstring("Releases file mapping"),
  932.     ]
  933.     BOOL WINAPI UnmapViewOfFile(
  934.         [in] LPVOID lpBaseAddress
  935.         );
  936.  
  937.     [
  938.     usesgetlasterror,
  939.     entry("CreateFileMappingA"),
  940.     helpstring("Maps file to memory or creates shared memory (if hFile is -1), assigns lpName to mapping, and returns mapping handle"),
  941.     ]
  942.     HANDLE WINAPI CreateFileMapping(
  943.         [in] HANDLE hFile,
  944.         [in] DWORD lpFileMappingAttributes,
  945.         [in] DWORD flProtect,
  946.         [in] DWORD dwMaximumSizeHigh,
  947.         [in] DWORD dwMaximumSizeLow,
  948.         [in] LPCSTR lpName
  949.         );
  950.  
  951.     [
  952.     usesgetlasterror,
  953.     entry("OpenFileMappingA"),
  954.     helpstring("Opens existing mapping specified by lpName"),
  955.     ]
  956.     HANDLE WINAPI OpenFileMapping(
  957.         [in] DWORD dwDesiredAccess,
  958.         [in] BOOL bInheritHandle,
  959.         [in] LPCSTR lpName
  960.         );
  961.  
  962.     /*
  963.     BOOL WINAPI IsTextUnicode(
  964.         CONST LPVOID lpBuffer,
  965.         int cb,
  966.         LPINT lpi
  967.         );
  968.     */
  969.  
  970.     /* TLS Not Implemented
  971.     DWORD WINAPI TlsAlloc(
  972.         VOID
  973.         );
  974.  
  975.     //define TLS_OUT_OF_INDEXES (DWORD)0xFFFFFFFF
  976.  
  977.     LPVOID WINAPI TlsGetValue(
  978.         DWORD dwTlsIndex
  979.         );
  980.  
  981.     BOOL WINAPI TlsSetValue(
  982.         DWORD dwTlsIndex,
  983.         LPVOID lpTlsValue
  984.         );
  985.  
  986.     BOOL WINAPI TlsFree(
  987.         DWORD dwTlsIndex
  988.         );
  989.  
  990.     const DWORD SHUTDOWN_NORETRY               = 0x00000001;
  991.     */
  992.  
  993.  
  994.     /* Some directory not implemented
  995.     BOOL WINAPI SetCurrentDirectoryA(
  996.         LPCSTR lpPathName
  997.         );
  998.  
  999.     DWORD WINAPI GetCurrentDirectoryA(
  1000.         DWORD nBufferLength,
  1001.         LPSTR lpBuffer
  1002.         );
  1003.  
  1004.     BOOL WINAPI CreateDirectoryA(
  1005.         LPCSTR lpPathName,
  1006.         LPSECURITY_ATTRIBUTES lpSecurityAttributes
  1007.         );
  1008.  
  1009.     BOOL WINAPI CreateDirectoryExA(
  1010.         LPCSTR lpTemplateDirectory,
  1011.         LPCSTR lpNewDirectory,
  1012.         LPSECURITY_ATTRIBUTES lpSecurityAttributes
  1013.         );
  1014.  
  1015.     BOOL WINAPI RemoveDirectoryA(
  1016.         LPCSTR lpPathName
  1017.         );
  1018.  
  1019.     const DWORD DDD_RAW_TARGET_PATH        = 0x00000001;
  1020.     const DWORD DDD_REMOVE_DEFINITION      = 0x00000002;
  1021.     const DWORD DDD_EXACT_MATCH_ON_REMOVE  = 0x00000004;
  1022.  
  1023.  
  1024.     BOOL WINAPI DefineDosDeviceA(
  1025.         DWORD dwFlags,
  1026.         LPCSTR lpDeviceName,
  1027.         LPCSTR lpTargetPath
  1028.         );
  1029.  
  1030.     DWORD WINAPI QueryDosDeviceA(
  1031.         LPCSTR lpDeviceName,
  1032.         LPSTR lpTargetPath,
  1033.         DWORD ucchMax
  1034.         );
  1035.  
  1036.     */
  1037.  
  1038.     /* Event logging not implemented
  1039.     BOOL WINAPI ClearEventLogA (
  1040.         HANDLE hEventLog,
  1041.         LPCSTR lpBackupFileName
  1042.         );
  1043.  
  1044.     BOOL WINAPI BackupEventLogA (
  1045.         HANDLE hEventLog,
  1046.         LPCSTR lpBackupFileName
  1047.         );
  1048.  
  1049.     BOOL WINAPI CloseEventLog (
  1050.         HANDLE hEventLog
  1051.         );
  1052.  
  1053.     BOOL WINAPI DeregisterEventSource (
  1054.         HANDLE hEventLog
  1055.         );
  1056.  
  1057.     BOOL WINAPI NotifyChangeEventLog (
  1058.         HANDLE hEventLog,
  1059.         HANDLE hEvent
  1060.         );
  1061.  
  1062.     BOOL WINAPI GetNumberOfEventLogRecords (
  1063.         HANDLE hEventLog,
  1064.         PDWORD NumberOfRecords
  1065.         );
  1066.  
  1067.     BOOL WINAPI GetOldestEventLogRecord (
  1068.         HANDLE hEventLog,
  1069.         PDWORD OldestRecord
  1070.         );
  1071.  
  1072.     HANDLE WINAPI OpenEventLogA (
  1073.         LPCSTR lpUNCServerName,
  1074.         LPCSTR lpSourceName
  1075.         );
  1076.  
  1077.     HANDLE WINAPI RegisterEventSourceA (
  1078.         LPCSTR lpUNCServerName,
  1079.         LPCSTR lpSourceName
  1080.         );
  1081.  
  1082.     HANDLE WINAPI OpenBackupEventLogA (
  1083.         LPCSTR lpUNCServerName,
  1084.         LPCSTR lpFileName
  1085.         );
  1086.  
  1087.     BOOL WINAPI ReadEventLogA (
  1088.          HANDLE     hEventLog,
  1089.          DWORD      dwReadFlags,
  1090.          DWORD      dwRecordOffset,
  1091.          LPVOID     lpBuffer,
  1092.          DWORD      nNumberOfBytesToRead,
  1093.          DWORD      *pnBytesRead,
  1094.          DWORD      *pnMinNumberOfBytesNeeded
  1095.         );
  1096.  
  1097.     BOOL WINAPI ReportEventA (
  1098.          HANDLE     hEventLog,
  1099.          WORD       wType,
  1100.          WORD       wCategory,
  1101.          DWORD      dwEventID,
  1102.          PSID       lpUserSid,
  1103.          WORD       wNumStrings,
  1104.          DWORD      dwDataSize,
  1105.          LPCSTR   *lpStrings,
  1106.          LPVOID     lpRawData
  1107.         );
  1108.     */
  1109.  
  1110.     /* Security Not implemented
  1111.     BOOL WINAPI DuplicateToken(
  1112.         HANDLE ExistingTokenHandle,
  1113.         SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
  1114.         PHANDLE DuplicateTokenHandle
  1115.         );
  1116.  
  1117.     BOOL WINAPI GetKernelObjectSecurity (
  1118.         HANDLE Handle,
  1119.         SECURITY_INFORMATION RequestedInformation,
  1120.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1121.         DWORD nLength,
  1122.         LPDWORD lpnLengthNeeded
  1123.         );
  1124.  
  1125.     BOOL WINAPI ImpersonateNamedPipeClient(
  1126.         HANDLE hNamedPipe
  1127.         );
  1128.  
  1129.     BOOL WINAPI ImpersonateSelf(
  1130.         SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
  1131.         );
  1132.  
  1133.  
  1134.     BOOL WINAPI RevertToSelf (
  1135.         VOID
  1136.         );
  1137.  
  1138.     BOOL WINAPI SetThreadToken (
  1139.         PHANDLE Thread,
  1140.         HANDLE Token
  1141.         );
  1142.  
  1143.     BOOL WINAPI AccessCheck (
  1144.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1145.         HANDLE ClientToken,
  1146.         DWORD DesiredAccess,
  1147.         PGENERIC_MAPPING GenericMapping,
  1148.         PPRIVILEGE_SET PrivilegeSet,
  1149.         LPDWORD PrivilegeSetLength,
  1150.         LPDWORD GrantedAccess,
  1151.         LPBOOL AccessStatus
  1152.         );
  1153.  
  1154.  
  1155.     BOOL WINAPI OpenProcessToken (
  1156.         HANDLE ProcessHandle,
  1157.         DWORD DesiredAccess,
  1158.         PHANDLE TokenHandle
  1159.         );
  1160.  
  1161.  
  1162.     BOOL WINAPI OpenThreadToken (
  1163.         HANDLE ThreadHandle,
  1164.         DWORD DesiredAccess,
  1165.         BOOL OpenAsSelf,
  1166.         PHANDLE TokenHandle
  1167.         );
  1168.  
  1169.  
  1170.     BOOL WINAPI GetTokenInformation (
  1171.         HANDLE TokenHandle,
  1172.         TOKEN_INFORMATION_CLASS TokenInformationClass,
  1173.         LPVOID TokenInformation,
  1174.         DWORD TokenInformationLength,
  1175.         PDWORD ReturnLength
  1176.         );
  1177.  
  1178.  
  1179.     BOOL WINAPI SetTokenInformation (
  1180.         HANDLE TokenHandle,
  1181.         TOKEN_INFORMATION_CLASS TokenInformationClass,
  1182.         LPVOID TokenInformation,
  1183.         DWORD TokenInformationLength
  1184.         );
  1185.  
  1186.  
  1187.     BOOL WINAPI AdjustTokenPrivileges (
  1188.         HANDLE TokenHandle,
  1189.         BOOL DisableAllPrivileges,
  1190.         PTOKEN_PRIVILEGES NewState,
  1191.         DWORD BufferLength,
  1192.         PTOKEN_PRIVILEGES PreviousState,
  1193.         PDWORD ReturnLength
  1194.         );
  1195.  
  1196.  
  1197.     BOOL WINAPI AdjustTokenGroups (
  1198.         HANDLE TokenHandle,
  1199.         BOOL ResetToDefault,
  1200.         PTOKEN_GROUPS NewState,
  1201.         DWORD BufferLength,
  1202.         PTOKEN_GROUPS PreviousState,
  1203.         PDWORD ReturnLength
  1204.         );
  1205.  
  1206.  
  1207.     BOOL WINAPI PrivilegeCheck (
  1208.         HANDLE ClientToken,
  1209.         PPRIVILEGE_SET RequiredPrivileges,
  1210.         LPBOOL pfResult
  1211.         );
  1212.  
  1213.  
  1214.     BOOL WINAPI AccessCheckAndAuditAlarmA (
  1215.         LPCSTR SubsystemName,
  1216.         LPVOID HandleId,
  1217.         LPSTR ObjectTypeName,
  1218.         LPSTR ObjectName,
  1219.         PSECURITY_DESCRIPTOR SecurityDescriptor,
  1220.         DWORD DesiredAccess,
  1221.         PGENERIC_MAPPING GenericMapping,
  1222.         BOOL ObjectCreation,
  1223.         LPDWORD GrantedAccess,
  1224.         LPBOOL AccessStatus,
  1225.         LPBOOL pfGenerateOnClose
  1226.         );
  1227.  
  1228.     BOOL WINAPI ObjectOpenAuditAlarmA (
  1229.         LPCSTR SubsystemName,
  1230.         LPVOID HandleId,
  1231.         LPSTR ObjectTypeName,
  1232.         LPSTR ObjectName,
  1233.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1234.         HANDLE ClientToken,
  1235.         DWORD DesiredAccess,
  1236.         DWORD GrantedAccess,
  1237.         PPRIVILEGE_SET Privileges,
  1238.         BOOL ObjectCreation,
  1239.         BOOL AccessGranted,
  1240.         LPBOOL GenerateOnClose
  1241.         );
  1242.  
  1243.     BOOL WINAPI ObjectPrivilegeAuditAlarmA (
  1244.         LPCSTR SubsystemName,
  1245.         LPVOID HandleId,
  1246.         HANDLE ClientToken,
  1247.         DWORD DesiredAccess,
  1248.         PPRIVILEGE_SET Privileges,
  1249.         BOOL AccessGranted
  1250.         );
  1251.  
  1252.     BOOL WINAPI ObjectCloseAuditAlarmA (
  1253.         LPCSTR SubsystemName,
  1254.         LPVOID HandleId,
  1255.         BOOL GenerateOnClose
  1256.         );
  1257.  
  1258.     BOOL WINAPI PrivilegedServiceAuditAlarmA (
  1259.         LPCSTR SubsystemName,
  1260.         LPCSTR ServiceName,
  1261.         HANDLE ClientToken,
  1262.         PPRIVILEGE_SET Privileges,
  1263.         BOOL AccessGranted
  1264.         );
  1265.  
  1266.     BOOL WINAPI IsValidSid (
  1267.         PSID pSid
  1268.         );
  1269.  
  1270.  
  1271.     BOOL WINAPI EqualSid (
  1272.         PSID pSid1,
  1273.         PSID pSid2
  1274.         );
  1275.  
  1276.  
  1277.     BOOL WINAPI EqualPrefixSid (
  1278.         PSID pSid1,
  1279.         PSID pSid2
  1280.         );
  1281.  
  1282.  
  1283.     DWORD WINAPI GetSidLengthRequired (
  1284.         UCHAR nSubAuthorityCount
  1285.         );
  1286.  
  1287.  
  1288.     BOOL WINAPI AllocateAndInitializeSid (
  1289.         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
  1290.         BYTE nSubAuthorityCount,
  1291.         DWORD nSubAuthority0,
  1292.         DWORD nSubAuthority1,
  1293.         DWORD nSubAuthority2,
  1294.         DWORD nSubAuthority3,
  1295.         DWORD nSubAuthority4,
  1296.         DWORD nSubAuthority5,
  1297.         DWORD nSubAuthority6,
  1298.         DWORD nSubAuthority7,
  1299.         PSID *pSid
  1300.         );
  1301.  
  1302.     PVOID WINAPI FreeSid(
  1303.         PSID pSid
  1304.         );
  1305.  
  1306.     BOOL WINAPI InitializeSid (
  1307.         PSID Sid,
  1308.         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
  1309.         BYTE nSubAuthorityCount
  1310.         );
  1311.  
  1312.  
  1313.     PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority (
  1314.         PSID pSid
  1315.         );
  1316.  
  1317.  
  1318.     PDWORD WINAPI GetSidSubAuthority (
  1319.         PSID pSid,
  1320.         DWORD nSubAuthority
  1321.         );
  1322.  
  1323.  
  1324.     PUCHAR WINAPI GetSidSubAuthorityCount (
  1325.         PSID pSid
  1326.         );
  1327.  
  1328.  
  1329.     DWORD WINAPI GetLengthSid (
  1330.         PSID pSid
  1331.         );
  1332.  
  1333.  
  1334.     BOOL WINAPI CopySid (
  1335.         DWORD nDestinationSidLength,
  1336.         PSID pDestinationSid,
  1337.         PSID pSourceSid
  1338.         );
  1339.  
  1340.  
  1341.     BOOL WINAPI AreAllAccessesGranted (
  1342.         DWORD GrantedAccess,
  1343.         DWORD DesiredAccess
  1344.         );
  1345.  
  1346.  
  1347.     BOOL WINAPI AreAnyAccessesGranted (
  1348.         DWORD GrantedAccess,
  1349.         DWORD DesiredAccess
  1350.         );
  1351.  
  1352.  
  1353.     VOID WINAPI MapGenericMask (
  1354.         PDWORD AccessMask,
  1355.         PGENERIC_MAPPING GenericMapping
  1356.         );
  1357.  
  1358.  
  1359.     BOOL WINAPI IsValidAcl (
  1360.         PACL pAcl
  1361.         );
  1362.  
  1363.  
  1364.     BOOL WINAPI InitializeAcl (
  1365.         PACL pAcl,
  1366.         DWORD nAclLength,
  1367.         DWORD dwAclRevision
  1368.         );
  1369.  
  1370.  
  1371.     BOOL WINAPI GetAclInformation (
  1372.         PACL pAcl,
  1373.         LPVOID pAclInformation,
  1374.         DWORD nAclInformationLength,
  1375.         ACL_INFORMATION_CLASS dwAclInformationClass
  1376.         );
  1377.  
  1378.  
  1379.     BOOL WINAPI SetAclInformation (
  1380.         PACL pAcl,
  1381.         LPVOID pAclInformation,
  1382.         DWORD nAclInformationLength,
  1383.         ACL_INFORMATION_CLASS dwAclInformationClass
  1384.         );
  1385.  
  1386.  
  1387.     BOOL WINAPI AddAce (
  1388.         PACL pAcl,
  1389.         DWORD dwAceRevision,
  1390.         DWORD dwStartingAceIndex,
  1391.         LPVOID pAceList,
  1392.         DWORD nAceListLength
  1393.         );
  1394.  
  1395.  
  1396.     BOOL WINAPI DeleteAce (
  1397.         PACL pAcl,
  1398.         DWORD dwAceIndex
  1399.         );
  1400.  
  1401.  
  1402.     BOOL WINAPI GetAce (
  1403.         PACL pAcl,
  1404.         DWORD dwAceIndex,
  1405.         LPVOID *pAce
  1406.         );
  1407.  
  1408.  
  1409.     BOOL WINAPI AddAccessAllowedAce (
  1410.         PACL pAcl,
  1411.         DWORD dwAceRevision,
  1412.         DWORD AccessMask,
  1413.         PSID pSid
  1414.         );
  1415.  
  1416.  
  1417.     BOOL WINAPI AddAccessDeniedAce (
  1418.         PACL pAcl,
  1419.         DWORD dwAceRevision,
  1420.         DWORD AccessMask,
  1421.         PSID pSid
  1422.         );
  1423.  
  1424.  
  1425.     BOOL WINAPI AddAuditAccessAce(
  1426.         PACL pAcl,
  1427.         DWORD dwAceRevision,
  1428.         DWORD dwAccessMask,
  1429.         PSID pSid,
  1430.         BOOL bAuditSuccess,
  1431.         BOOL bAuditFailure
  1432.         );
  1433.  
  1434.  
  1435.     BOOL WINAPI FindFirstFreeAce (
  1436.         PACL pAcl,
  1437.         LPVOID *pAce
  1438.         );
  1439.  
  1440.  
  1441.     BOOL WINAPI InitializeSecurityDescriptor (
  1442.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1443.         DWORD dwRevision
  1444.         );
  1445.  
  1446.  
  1447.     BOOL WINAPI IsValidSecurityDescriptor (
  1448.         PSECURITY_DESCRIPTOR pSecurityDescriptor
  1449.         );
  1450.  
  1451.  
  1452.     DWORD WINAPI GetSecurityDescriptorLength (
  1453.         PSECURITY_DESCRIPTOR pSecurityDescriptor
  1454.         );
  1455.  
  1456.  
  1457.     BOOL WINAPI GetSecurityDescriptorControl (
  1458.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1459.         PSECURITY_DESCRIPTOR_CONTROL pControl,
  1460.         LPDWORD lpdwRevision
  1461.         );
  1462.  
  1463.  
  1464.     BOOL WINAPI SetSecurityDescriptorDacl (
  1465.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1466.         BOOL bDaclPresent,
  1467.         PACL pDacl,
  1468.         BOOL bDaclDefaulted
  1469.         );
  1470.  
  1471.  
  1472.     BOOL WINAPI GetSecurityDescriptorDacl (
  1473.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1474.         LPBOOL lpbDaclPresent,
  1475.         PACL *pDacl,
  1476.         LPBOOL lpbDaclDefaulted
  1477.         );
  1478.  
  1479.  
  1480.     BOOL WINAPI SetSecurityDescriptorSacl (
  1481.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1482.         BOOL bSaclPresent,
  1483.         PACL pSacl,
  1484.         BOOL bSaclDefaulted
  1485.         );
  1486.  
  1487.  
  1488.     BOOL WINAPI GetSecurityDescriptorSacl (
  1489.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1490.         LPBOOL lpbSaclPresent,
  1491.         PACL *pSacl,
  1492.         LPBOOL lpbSaclDefaulted
  1493.         );
  1494.  
  1495.  
  1496.     BOOL WINAPI SetSecurityDescriptorOwner (
  1497.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1498.         PSID pOwner,
  1499.         BOOL bOwnerDefaulted
  1500.         );
  1501.  
  1502.  
  1503.     BOOL WINAPI GetSecurityDescriptorOwner (
  1504.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1505.         PSID *pOwner,
  1506.         LPBOOL lpbOwnerDefaulted
  1507.         );
  1508.  
  1509.  
  1510.     BOOL WINAPI SetSecurityDescriptorGroup (
  1511.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1512.         PSID pGroup,
  1513.         BOOL bGroupDefaulted
  1514.         );
  1515.  
  1516.  
  1517.     BOOL WINAPI GetSecurityDescriptorGroup (
  1518.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1519.         PSID *pGroup,
  1520.         LPBOOL lpbGroupDefaulted
  1521.         );
  1522.  
  1523.  
  1524.     BOOL WINAPI CreatePrivateObjectSecurity (
  1525.         PSECURITY_DESCRIPTOR ParentDescriptor,
  1526.         PSECURITY_DESCRIPTOR CreatorDescriptor,
  1527.         PSECURITY_DESCRIPTOR * NewDescriptor,
  1528.         BOOL IsDirectoryObject,
  1529.         HANDLE Token,
  1530.         PGENERIC_MAPPING GenericMapping
  1531.         );
  1532.  
  1533.  
  1534.     BOOL WINAPI SetPrivateObjectSecurity (
  1535.         SECURITY_INFORMATION SecurityInformation,
  1536.         PSECURITY_DESCRIPTOR ModificationDescriptor,
  1537.         PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
  1538.         PGENERIC_MAPPING GenericMapping,
  1539.         HANDLE Token
  1540.         );
  1541.  
  1542.  
  1543.     BOOL WINAPI GetPrivateObjectSecurity (
  1544.         PSECURITY_DESCRIPTOR ObjectDescriptor,
  1545.         SECURITY_INFORMATION SecurityInformation,
  1546.         PSECURITY_DESCRIPTOR ResultantDescriptor,
  1547.         DWORD DescriptorLength,
  1548.         PDWORD ReturnLength
  1549.         );
  1550.  
  1551.  
  1552.     BOOL WINAPI DestroyPrivateObjectSecurity (
  1553.         PSECURITY_DESCRIPTOR * ObjectDescriptor
  1554.         );
  1555.  
  1556.  
  1557.     BOOL WINAPI MakeSelfRelativeSD (
  1558.         PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
  1559.         PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
  1560.         LPDWORD lpdwBufferLength
  1561.         );
  1562.  
  1563.  
  1564.     BOOL WINAPI MakeAbsoluteSD (
  1565.         PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
  1566.         PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
  1567.         LPDWORD lpdwAbsoluteSecurityDescriptorSize,
  1568.         PACL pDacl,
  1569.         LPDWORD lpdwDaclSize,
  1570.         PACL pSacl,
  1571.         LPDWORD lpdwSaclSize,
  1572.         PSID pOwner,
  1573.         LPDWORD lpdwOwnerSize,
  1574.         PSID pPrimaryGroup,
  1575.         LPDWORD lpdwPrimaryGroupSize
  1576.         );
  1577.  
  1578.  
  1579.     BOOL WINAPI SetFileSecurityA (
  1580.         LPCSTR lpFileName,
  1581.         SECURITY_INFORMATION SecurityInformation,
  1582.         PSECURITY_DESCRIPTOR pSecurityDescriptor
  1583.         );
  1584.  
  1585.     BOOL WINAPI GetFileSecurityA (
  1586.         LPCSTR lpFileName,
  1587.         SECURITY_INFORMATION RequestedInformation,
  1588.         PSECURITY_DESCRIPTOR pSecurityDescriptor,
  1589.         DWORD nLength,
  1590.         LPDWORD lpnLengthNeeded
  1591.         );
  1592.  
  1593.     BOOL WINAPI SetKernelObjectSecurity (
  1594.         HANDLE Handle,
  1595.         SECURITY_INFORMATION SecurityInformation,
  1596.         PSECURITY_DESCRIPTOR SecurityDescriptor
  1597.         );
  1598.     */
  1599.  
  1600.     [
  1601.     usesgetlasterror,
  1602.     entry("FindFirstChangeNotificationA"),
  1603.     helpstring("Sets initial change notification filter conditions and returns handle to wait for change matching the filter conditions occurs in the specified directory or subtree"),
  1604.     ]
  1605.     HANDLE WINAPI FindFirstChangeNotification(
  1606.         [in] LPCSTR lpPathName,
  1607.         [in] BOOL bWatchSubtree,
  1608.         [in] DWORD dwNotifyFilter
  1609.         );
  1610.  
  1611.     [
  1612.     usesgetlasterror,
  1613.     entry("FindNextChangeNotification"),
  1614.     helpstring("Requests change notification for next file event matching previously set filter conditions associated handle"),
  1615.     ]
  1616.     BOOL WINAPI FindNextChangeNotification(
  1617.         [in] HANDLE hChangeHandle
  1618.         );
  1619.  
  1620.     [
  1621.     usesgetlasterror,
  1622.     entry("FindCloseChangeNotification"),
  1623.     helpstring("Stops file change notification filtering for the handle"),
  1624.     ]
  1625.     BOOL WINAPI FindCloseChangeNotification(
  1626.         [in] HANDLE hChangeHandle
  1627.         );
  1628.  
  1629.     /*
  1630.     BOOL WINAPI LookupAccountSidA(
  1631.         LPCSTR lpSystemName,
  1632.         PSID Sid,
  1633.         LPSTR Name,
  1634.         LPDWORD cbName,
  1635.         LPSTR ReferencedDomainName,
  1636.         LPDWORD cbReferencedDomainName,
  1637.         PSID_NAME_USE peUse
  1638.         );
  1639.  
  1640.     BOOL WINAPI LookupAccountNameA(
  1641.         LPCSTR lpSystemName,
  1642.         LPCSTR lpAccountName,
  1643.         PSID Sid,
  1644.         LPDWORD cbSid,
  1645.         LPSTR ReferencedDomainName,
  1646.         LPDWORD cbReferencedDomainName,
  1647.         PSID_NAME_USE peUse
  1648.         );
  1649.  
  1650.     BOOL WINAPI LookupPrivilegeValueA(
  1651.         LPCSTR lpSystemName,
  1652.         LPCSTR lpName,
  1653.         PLUID   lpLuid
  1654.         );
  1655.  
  1656.     BOOL WINAPI LookupPrivilegeNameA(
  1657.         LPCSTR lpSystemName,
  1658.         PLUID   lpLuid,
  1659.         LPSTR lpName,
  1660.         LPDWORD cbName
  1661.         );
  1662.  
  1663.     BOOL WINAPI LookupPrivilegeDisplayNameA(
  1664.         LPCSTR lpSystemName,
  1665.         LPCSTR lpName,
  1666.         LPSTR lpDisplayName,
  1667.         LPDWORD cbDisplayName,
  1668.         LPDWORD lpLanguageId
  1669.         );
  1670.  
  1671.     BOOL WINAPI AllocateLocallyUniqueId(
  1672.         PLUID Luid
  1673.         );
  1674.     */
  1675.  
  1676.     /* Miscellaneous not implemented
  1677.     VOID WINAPI SetFileApisToOEM( VOID );
  1678.  
  1679.     VOID WINAPI SetFileApisToANSI( VOID );
  1680.  
  1681.     BOOL WINAPI AreFileApisANSI( VOID );
  1682.  
  1683.     BOOL WINAPI SetPriorityClass(
  1684.         HANDLE hProcess,
  1685.         DWORD dwPriorityClass
  1686.         );
  1687.  
  1688.     DWORD WINAPI GetPriorityClass(
  1689.         HANDLE hProcess
  1690.         );
  1691.  
  1692.     BOOL WINAPI IsBadReadPtr(
  1693.         CONST VOID *lp,
  1694.         UINT ucb
  1695.         );
  1696.  
  1697.     BOOL WINAPI IsBadWritePtr(
  1698.         LPVOID lp,
  1699.         UINT ucb
  1700.         );
  1701.  
  1702.     BOOL WINAPI IsBadHugeReadPtr(
  1703.         CONST VOID *lp,
  1704.         UINT ucb
  1705.         );
  1706.  
  1707.     BOOL WINAPI IsBadHugeWritePtr(
  1708.         LPVOID lp,
  1709.         UINT ucb
  1710.         );
  1711.  
  1712.     BOOL WINAPI IsBadCodePtr(
  1713.         FARPROC lpfn
  1714.         );
  1715.  
  1716.     BOOL WINAPI IsBadStringPtrA(
  1717.         LPCSTR lpsz,
  1718.         UINT ucchMax
  1719.         );
  1720.     */
  1721.  
  1722.     /* Performance counter not implemented
  1723.  
  1724.     BOOL WINAPI QueryPerformanceCounter(
  1725.         LARGE_INTEGER *lpPerformanceCount
  1726.         );
  1727.  
  1728.     BOOL WINAPI QueryPerformanceFrequency(
  1729.         LARGE_INTEGER *lpFrequency
  1730.         );
  1731.     */
  1732.  
  1733.  
  1734. }
  1735.  
  1736. [
  1737. uuid(54674049-3A82-101B-8181-00AA003743D3),
  1738. helpstring("Win32 Base Constants"),
  1739. dllname("NOSUCH.DLL")
  1740. ]
  1741. module WinBaseConst {
  1742.  
  1743.     [ helpstring("GetComputerName: Maximum name length") ]
  1744.     const int MAX_COMPUTERNAME_LENGTH  = 15;
  1745.  
  1746.     [ helpstring("Create handle functions: Invalid handle") ]
  1747.     const long INVALID_HANDLE_VALUE  = -1;
  1748.     const long INVALID_FILE_SIZE = 0xFFFFFFFF;
  1749.  
  1750.     /*
  1751.     const int FILE_BEGIN          = 0;
  1752.     const int FILE_CURRENT        = 1;
  1753.     const int FILE_END            = 2;
  1754.  
  1755.     const DWORD TIME_ZONE_ID_INVALID = 0xFFFFFFFF;
  1756.     */
  1757.  
  1758.     const long WAIT_FAILED          = 0xFFFFFFFF;
  1759.     const long WAIT_OBJECT_0        = 0x00000000;
  1760.  
  1761.     const long WAIT_ABANDONED       = 0x00000080;
  1762.     const long WAIT_ABANDONED_0     = 0x00000080;
  1763.  
  1764.     const long WAIT_TIMEOUT         = 0x00000102;
  1765.     const long WAIT_IO_COMPLETION   = 0x000000C0;
  1766.     const long STILL_ACTIVE         = 0x00000103;
  1767.  
  1768.     const long FILE_NOTIFY_CHANGE_FILE_NAME  = 0x00000001;
  1769.     const long FILE_NOTIFY_CHANGE_DIR_NAME   = 0x00000002;
  1770.     const long FILE_NOTIFY_CHANGE_ATTRIBUTES = 0x00000004;
  1771.     const long FILE_NOTIFY_CHANGE_SIZE       = 0x00000008;
  1772.     const long FILE_NOTIFY_CHANGE_LAST_WRITE = 0x00000010;
  1773.     const long FILE_NOTIFY_CHANGE_SECURITY   = 0x00000100;
  1774.  
  1775.     //
  1776.     // File creation flags must start at the high end since they
  1777.     // are combined with the attributes
  1778.     //
  1779.  
  1780.     const long FILE_FLAG_WRITE_THROUGH      = 0x80000000;
  1781.     const long FILE_FLAG_OVERLAPPED         = 0x40000000;
  1782.     const long FILE_FLAG_NO_BUFFERING       = 0x20000000;
  1783.     const long FILE_FLAG_RANDOM_ACCESS      = 0x10000000;
  1784.     const long FILE_FLAG_SEQUENTIAL_SCAN    = 0x08000000;
  1785.     const long FILE_FLAG_DELETE_ON_CLOSE    = 0x04000000;
  1786.     const long FILE_FLAG_BACKUP_SEMANTICS   = 0x02000000;
  1787.     const long FILE_FLAG_POSIX_SEMANTICS    = 0x01000000;
  1788.  
  1789.     const long CREATE_NEW           = 1;
  1790.     const long CREATE_ALWAYS        = 2;
  1791.     const long OPEN_EXISTING        = 3;
  1792.     const long OPEN_ALWAYS          = 4;
  1793.     const long TRUNCATE_EXISTING    = 5;
  1794.  
  1795.     const long GENERIC_READ         = 0x80000000;
  1796.     const long GENERIC_WRITE        = 0x40000000;
  1797.     const long GENERIC_EXECUTE      = 0x20000000;
  1798.     const long GENERIC_ALL          = 0x10000000;
  1799.  
  1800.     const long FILE_SHARE_READ          = 0x00000001;
  1801.     const long FILE_SHARE_WRITE         = 0x00000002;
  1802.     const long FILE_ATTRIBUTE_READONLY  = 0x00000001;
  1803.     const long FILE_ATTRIBUTE_HIDDEN    = 0x00000002;
  1804.     const long FILE_ATTRIBUTE_SYSTEM    = 0x00000004;
  1805.     const long FILE_ATTRIBUTE_DIRECTORY = 0x00000010;
  1806.     const long FILE_ATTRIBUTE_ARCHIVE   = 0x00000020;
  1807.     const long FILE_ATTRIBUTE_NORMAL    = 0x00000080;
  1808.     const long FILE_ATTRIBUTE_TEMPORARY = 0x00000100;
  1809.     const long FILE_ATTRIBUTE_COMPRESSED = 0x00000800;
  1810.  
  1811.     /*
  1812.     //
  1813.     // Define the NamedPipe definitions
  1814.     //
  1815.  
  1816.     //
  1817.     // Define the dwOpenMode values for CreateNamedPipe
  1818.     //
  1819.  
  1820.     const DWORD PIPE_ACCESS_INBOUND        = 0x00000001;
  1821.     const DWORD PIPE_ACCESS_OUTBOUND       = 0x00000002;
  1822.     const DWORD PIPE_ACCESS_DUPLEX         = 0x00000003;
  1823.  
  1824.     //
  1825.     // Define the Named Pipe End flags for GetNamedPipeInfo
  1826.     //
  1827.  
  1828.     const DWORD PIPE_CLIENT_END            = 0x00000000;
  1829.     const DWORD PIPE_SERVER_END            = 0x00000001;
  1830.  
  1831.     //
  1832.     // Define the dwPipeMode values for CreateNamedPipe
  1833.     //
  1834.  
  1835.     const DWORD PIPE_WAIT                  = 0x00000000;
  1836.     const DWORD PIPE_NOWAIT                = 0x00000001;
  1837.     const DWORD PIPE_READMODE_BYTE         = 0x00000000;
  1838.     const DWORD PIPE_READMODE_MESSAGE      = 0x00000002;
  1839.     const DWORD PIPE_TYPE_BYTE             = 0x00000000;
  1840.     const DWORD PIPE_TYPE_MESSAGE          = 0x00000004;
  1841.  
  1842.     //
  1843.     // Define the well known values for CreateNamedPipe nMaxInstances
  1844.     //
  1845.  
  1846.     const int PIPE_UNLIMITED_INSTANCES   = 255;
  1847.     */
  1848.  
  1849.     /*
  1850.     //
  1851.     // Define the Security Quality of Service bits to be passed
  1852.     // into CreateFile
  1853.     //
  1854.  
  1855.     //define SECURITY_ANONYMOUS         ( SecurityAnonymous      << 16 )
  1856.     //define SECURITY_IDENTIFICATION    ( SecurityIdentification << 16 )
  1857.     //define SECURITY_IMPERSONATION     ( SecurityImpersonation  << 16 )
  1858.     //define SECURITY_DELEGATION        ( SecurityDelegation     << 16 )
  1859.  
  1860.     const DWORD SECURITY_CONTEXT_TRACKING  = 0x00040000;
  1861.     const DWORD SECURITY_EFFECTIVE_ONLY    = 0x00080000;
  1862.  
  1863.     const DWORD SECURITY_SQOS_PRESENT      = 0x00100000;
  1864.     const DWORD SECURITY_VALID_SQOS_FLAGS  = 0x001F0000;
  1865.     */
  1866.  
  1867.     //
  1868.     //  File structures
  1869.     //
  1870.  
  1871.     /*
  1872.     typedef struct _OVERLAPPED {
  1873.         DWORD   Internal;
  1874.         DWORD   InternalHigh;
  1875.         DWORD   Offset;
  1876.         DWORD   OffsetHigh;
  1877.         HANDLE  hEvent;
  1878.     } OVERLAPPED, *LPOVERLAPPED;
  1879.     */
  1880.  
  1881.     /*
  1882.     typedef struct _SECURITY_ATTRIBUTES {
  1883.         DWORD nLength;
  1884.         LPVOID lpSecurityDescriptor;
  1885.         BOOL bInheritHandle;
  1886.     } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
  1887.     */
  1888.  
  1889.     /*
  1890.     typedef struct _PROCESS_INFORMATION {
  1891.         HANDLE hProcess;
  1892.         HANDLE hThread;
  1893.         DWORD dwProcessId;
  1894.         DWORD dwThreadId;
  1895.     } PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
  1896.     */
  1897.  
  1898.     //
  1899.     //  File System time stamps are represented with the following structure:
  1900.     //
  1901.  
  1902.     /*
  1903.     typedef struct _FILETIME {
  1904.         DWORD dwLowDateTime;
  1905.         DWORD dwHighDateTime;
  1906.     } FILETIME, *PFILETIME, *LPFILETIME;
  1907.     */
  1908.  
  1909.     //
  1910.     // System time is represented with the following structure:
  1911.     //
  1912.  
  1913.     /*
  1914.     typedef struct _SYSTEMTIME {
  1915.         WORD wYear;
  1916.         WORD wMonth;
  1917.         WORD wDayOfWeek;
  1918.         WORD wDay;
  1919.         WORD wHour;
  1920.         WORD wMinute;
  1921.         WORD wSecond;
  1922.         WORD wMilliseconds;
  1923.     } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
  1924.     */
  1925.  
  1926.     /*
  1927.     typedef DWORD (WINAPI *PTHREAD_START_ROUTINE)(
  1928.         LPVOID lpThreadParameter
  1929.         );
  1930.     typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE;
  1931.  
  1932.     typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;
  1933.     typedef PRTL_CRITICAL_SECTION PCRITICAL_SECTION;
  1934.     typedef PRTL_CRITICAL_SECTION LPCRITICAL_SECTION;
  1935.  
  1936.     typedef RTL_CRITICAL_SECTION_DEBUG CRITICAL_SECTION_DEBUG;
  1937.     typedef PRTL_CRITICAL_SECTION_DEBUG PCRITICAL_SECTION_DEBUG;
  1938.     typedef PRTL_CRITICAL_SECTION_DEBUG LPCRITICAL_SECTION_DEBUG;
  1939.  
  1940.     #ifdef _X86_
  1941.     typedef PLDT_ENTRY LPLDT_ENTRY;
  1942.     #else
  1943.     typedef LPVOID LPLDT_ENTRY;
  1944.     #endif
  1945.  
  1946.     //define MUTEX_MODIFY_STATE MUTANT_QUERY_STATE
  1947.     //define MUTEX_ALL_ACCESS MUTANT_ALL_ACCESS
  1948.  
  1949.     /*
  1950.     typedef struct _SYSTEM_INFO {
  1951.         DWORD dwOemId;
  1952.         DWORD dwPageSize;
  1953.         LPVOID lpMinimumApplicationAddress;
  1954.         LPVOID lpMaximumApplicationAddress;
  1955.         DWORD dwActiveProcessorMask;
  1956.         DWORD dwNumberOfProcessors;
  1957.         DWORD dwProcessorType;
  1958.         DWORD dwAllocationGranularity;
  1959.         DWORD dwReserved;
  1960.     } SYSTEM_INFO, *LPSYSTEM_INFO;
  1961.     */
  1962.  
  1963.     /*
  1964.     typedef struct _MEMORYSTATUS {
  1965.         DWORD dwLength;
  1966.         DWORD dwMemoryLoad;
  1967.         DWORD dwTotalPhys;
  1968.         DWORD dwAvailPhys;
  1969.         DWORD dwTotalPageFile;
  1970.         DWORD dwAvailPageFile;
  1971.         DWORD dwTotalVirtual;
  1972.         DWORD dwAvailVirtual;
  1973.     } MEMORYSTATUS, *LPMEMORYSTATUS;
  1974.     */
  1975.  
  1976.     /*
  1977.     // dwCreationFlag values
  1978.  
  1979.     const DWORD DEBUG_PROCESS              = 0x00000001;
  1980.     const DWORD DEBUG_ONLY_THIS_PROCESS    = 0x00000002;
  1981.  
  1982.     const DWORD CREATE_SUSPENDED           = 0x00000004;
  1983.  
  1984.     const DWORD DETACHED_PROCESS           = 0x00000008;
  1985.  
  1986.     const DWORD CREATE_NEW_CONSOLE         = 0x00000010;
  1987.  
  1988.     const DWORD NORMAL_PRIORITY_CLASS      = 0x00000020;
  1989.     const DWORD IDLE_PRIORITY_CLASS        = 0x00000040;
  1990.     const DWORD HIGH_PRIORITY_CLASS        = 0x00000080;
  1991.     const DWORD REALTIME_PRIORITY_CLASS    = 0x00000100;
  1992.  
  1993.     const DWORD CREATE_NEW_PROCESS_GROUP   = 0x00000200;
  1994.     const DWORD CREATE_UNICODE_ENVIRONMENT = 0x00000400;
  1995.  
  1996.     const DWORD CREATE_SEPARATE_WOW_VDM    = 0x00000800;
  1997.  
  1998.     const DWORD CREATE_DEFAULT_ERROR_MODE  = 0x04000000;
  1999.     const DWORD CREATE_NO_WINDOW           = 0x08000000;
  2000.  
  2001.     //define THREAD_PRIORITY_LOWEST         THREAD_BASE_PRIORITY_MIN
  2002.     //define THREAD_PRIORITY_BELOW_NORMAL   (THREAD_PRIORITY_LOWEST+1)
  2003.     //define THREAD_PRIORITY_NORMAL         0
  2004.     //define THREAD_PRIORITY_HIGHEST        THREAD_BASE_PRIORITY_MAX
  2005.     //define THREAD_PRIORITY_ABOVE_NORMAL   (THREAD_PRIORITY_HIGHEST-1)
  2006.     //define THREAD_PRIORITY_ERROR_RETURN   (MAXLONG)
  2007.  
  2008.     //define THREAD_PRIORITY_TIME_CRITICAL  THREAD_BASE_PRIORITY_LOWRT
  2009.     //define THREAD_PRIORITY_IDLE           THREAD_BASE_PRIORITY_IDLE
  2010.     */
  2011.  
  2012.     /*
  2013.     // Debug APIs
  2014.     //
  2015.     const int EXCEPTION_DEBUG_EVENT      = 1;
  2016.     const int CREATE_THREAD_DEBUG_EVENT  = 2;
  2017.     const int CREATE_PROCESS_DEBUG_EVENT = 3;
  2018.     const int EXIT_THREAD_DEBUG_EVENT    = 4;
  2019.     const int EXIT_PROCESS_DEBUG_EVENT   = 5;
  2020.     const int LOAD_DLL_DEBUG_EVENT       = 6;
  2021.     const int UNLOAD_DLL_DEBUG_EVENT     = 7;
  2022.     const int OUTPUT_DEBUG_STRING_EVENT  = 8;
  2023.     const int RIP_EVENT                  = 9;
  2024.     */
  2025.  
  2026.     /*
  2027.     typedef struct _EXCEPTION_DEBUG_INFO {
  2028.         EXCEPTION_RECORD ExceptionRecord;
  2029.         DWORD dwFirstChance;
  2030.     } EXCEPTION_DEBUG_INFO, *LPEXCEPTION_DEBUG_INFO;
  2031.     */
  2032.  
  2033.     /*
  2034.     typedef struct _CREATE_THREAD_DEBUG_INFO {
  2035.         HANDLE hThread;
  2036.         LPVOID lpThreadLocalBase;
  2037.         LPTHREAD_START_ROUTINE lpStartAddress;
  2038.     } CREATE_THREAD_DEBUG_INFO, *LPCREATE_THREAD_DEBUG_INFO;
  2039.     */
  2040.  
  2041.     /*
  2042.     typedef struct _CREATE_PROCESS_DEBUG_INFO {
  2043.         HANDLE hFile;
  2044.         HANDLE hProcess;
  2045.         HANDLE hThread;
  2046.         LPVOID lpBaseOfImage;
  2047.         DWORD dwDebugInfoFileOffset;
  2048.         DWORD nDebugInfoSize;
  2049.         LPVOID lpThreadLocalBase;
  2050.         LPTHREAD_START_ROUTINE lpStartAddress;
  2051.         LPVOID lpImageName;
  2052.         WORD fUnicode;
  2053.     } CREATE_PROCESS_DEBUG_INFO, *LPCREATE_PROCESS_DEBUG_INFO;
  2054.     */
  2055.  
  2056.     /*
  2057.     typedef struct _EXIT_THREAD_DEBUG_INFO {
  2058.         DWORD dwExitCode;
  2059.     } EXIT_THREAD_DEBUG_INFO, *LPEXIT_THREAD_DEBUG_INFO;
  2060.     */
  2061.  
  2062.     /*
  2063.     typedef struct _EXIT_PROCESS_DEBUG_INFO {
  2064.         DWORD dwExitCode;
  2065.     } EXIT_PROCESS_DEBUG_INFO, *LPEXIT_PROCESS_DEBUG_INFO;
  2066.     */
  2067.  
  2068.     /*
  2069.     typedef struct _LOAD_DLL_DEBUG_INFO {
  2070.         HANDLE hFile;
  2071.         LPVOID lpBaseOfDll;
  2072.         DWORD dwDebugInfoFileOffset;
  2073.         DWORD nDebugInfoSize;
  2074.         LPVOID lpImageName;
  2075.         WORD fUnicode;
  2076.     } LOAD_DLL_DEBUG_INFO, *LPLOAD_DLL_DEBUG_INFO;
  2077.     */
  2078.  
  2079.     /*
  2080.     typedef struct _UNLOAD_DLL_DEBUG_INFO {
  2081.         LPVOID lpBaseOfDll;
  2082.     } UNLOAD_DLL_DEBUG_INFO, *LPUNLOAD_DLL_DEBUG_INFO;
  2083.     */
  2084.  
  2085.     /*
  2086.     typedef struct _OUTPUT_DEBUG_STRING_INFO {
  2087.         LPSTR lpDebugStringData;
  2088.         WORD fUnicode;
  2089.         WORD nDebugStringLength;
  2090.     } OUTPUT_DEBUG_STRING_INFO, *LPOUTPUT_DEBUG_STRING_INFO;
  2091.     */
  2092.  
  2093.     /*
  2094.     typedef struct _RIP_INFO {
  2095.         DWORD dwError;
  2096.         DWORD dwType;
  2097.     } RIP_INFO, *LPRIP_INFO;
  2098.     */
  2099.  
  2100.  
  2101.     /*
  2102.     typedef struct _DEBUG_EVENT {
  2103.         DWORD dwDebugEventCode;
  2104.         DWORD dwProcessId;
  2105.         DWORD dwThreadId;
  2106.         union {
  2107.             EXCEPTION_DEBUG_INFO Exception;
  2108.             CREATE_THREAD_DEBUG_INFO CreateThread;
  2109.             CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
  2110.             EXIT_THREAD_DEBUG_INFO ExitThread;
  2111.             EXIT_THREAD_DEBUG_INFO ExitProcess;
  2112.             LOAD_DLL_DEBUG_INFO LoadDll;
  2113.             UNLOAD_DLL_DEBUG_INFO UnloadDll;
  2114.             OUTPUT_DEBUG_STRING_INFO DebugString;
  2115.             RIP_INFO RipInfo;
  2116.         } u;
  2117.     } DEBUG_EVENT, *LPDEBUG_EVENT;
  2118.     */
  2119.  
  2120.     /*
  2121.     typedef PCONTEXT LPCONTEXT;
  2122.     typedef PEXCEPTION_RECORD LPEXCEPTION_RECORD;
  2123.     typedef PEXCEPTION_POINTERS LPEXCEPTION_POINTERS;
  2124.     */
  2125.  
  2126.     // GetDriveType return values
  2127.     [ helpstring("GetDriveType: Unknown drive") ]
  2128.     const int DRIVE_UNKNOWN     = 0;
  2129.     [ helpstring("GetDriveType: Invalid root drive") ]
  2130.     const int DRIVE_NO_ROOT_DIR = 1;
  2131.     [ helpstring("GetDriveType: Removable drive") ]
  2132.     const int DRIVE_REMOVABLE   = 2;
  2133.     [ helpstring("GetDriveType: Fixed drive") ]
  2134.     const int DRIVE_FIXED       = 3;
  2135.     [ helpstring("GetDriveType: Remote drive") ]
  2136.     const int DRIVE_REMOTE      = 4;
  2137.     [ helpstring("GetDriveType: CD-ROM drive") ]
  2138.     const int DRIVE_CDROM       = 5;
  2139.     [ helpstring("GetDriveType: RAM disk") ]
  2140.     const int DRIVE_RAMDISK     = 6;
  2141.  
  2142.     /*
  2143.     const WORD FILE_TYPE_UNKNOWN  = 0x0000;
  2144.     const WORD FILE_TYPE_DISK     = 0x0001;
  2145.     const WORD FILE_TYPE_CHAR     = 0x0002;
  2146.     const WORD FILE_TYPE_PIPE     = 0x0003;
  2147.     const WORD FILE_TYPE_REMOTE   = 0x8000;
  2148.  
  2149.  
  2150.     const int STD_INPUT_HANDLE    = -10;
  2151.     const int STD_OUTPUT_HANDLE   = -11;
  2152.     const int STD_ERROR_HANDLE    = -12;
  2153.  
  2154.     const DWORD NMPWAIT_WAIT_FOREVER           = 0xffffffff;
  2155.     const DWORD NMPWAIT_NOWAIT                 = 0x00000001;
  2156.     const DWORD NMPWAIT_USE_DEFAULT_WAIT       = 0x00000000;
  2157.  
  2158.     //define FS_CASE_IS_PRESERVED           FILE_CASE_PRESERVED_NAMES
  2159.     //define FS_CASE_SENSITIVE              FILE_CASE_SENSITIVE_SEARCH
  2160.     //define FS_UNICODE_STORED_ON_DISK      FILE_UNICODE_ON_DISK
  2161.     //define FS_PERSISTENT_ACLS             FILE_PERSISTENT_ACLS
  2162.     //define FS_VOL_IS_COMPRESSED           FILE_VOLUME_IS_COMPRESSED
  2163.     //define FS_FILE_COMPRESSION            FILE_FILE_COMPRESSION
  2164.     */
  2165.  
  2166.     [ helpstring("File mapping: Copy on write access") ]
  2167.     const long FILE_MAP_COPY        = 0x00000001; // SECTION_QUERY
  2168.     [ helpstring("File mapping: Read-write access") ]
  2169.     const long FILE_MAP_WRITE       = 0x00000002; // SECTION_MAP_WRITE
  2170.     [ helpstring("File mapping: Read-only access") ]
  2171.     const long FILE_MAP_READ        = 0x00000004; // SECTION_MAP_READ
  2172.     [ helpstring("File mapping: Read-write access") ]
  2173.     const long FILE_MAP_ALL_ACCESS  = 0x000F001F; // SECTION_ALL_ACCESS
  2174.  
  2175.     [ helpstring("File mapping: Read-only access to committed pages") ]
  2176.     const long PAGE_READONLY        = 0x02;
  2177.     [ helpstring("File mapping: Read-write access to committed pages") ]
  2178.     const long PAGE_READWRITE       = 0x04;
  2179.     [ helpstring("File mapping: Copy-on-write access to committed pages") ]
  2180.     const long PAGE_WRITECOPY       = 0x08;
  2181.  
  2182.     /*
  2183.     const long SEC_IMAGE            = 0x01000000;
  2184.     const long SEC_RESERVE          = 0x04000000;
  2185.     const long SEC_COMMIT           = 0x08000000;
  2186.     const long SEC_NOCACHE          = 0x10000000;
  2187.  
  2188.     const int OFS_MAXPATHNAME       = 128;
  2189.     */
  2190.  
  2191. }
  2192. #endif // WIN32
  2193.